సాంప్రదాయ ఉదాహరణ-ఆధారిత పరీక్షలను అధిగమించండి. ఈ సమగ్ర మార్గదర్శి fast-check ఉపయోగించి జావాస్క్రిప్ట్‌లో ప్రాపర్టీ-ఆధారిత పరీక్షను వివరిస్తుంది, ఇది తక్కువ కోడ్‌తో ఎక్కువ బగ్స్‌ను కనుగొనడంలో మీకు సహాయపడుతుంది.
ఉదాహరణలకు మించి: జావాస్క్రిప్ట్‌లో ప్రాపర్టీ-ఆధారిత పరీక్షపై ఒక లోతైన విశ్లేషణ
సాఫ్ట్‌వేర్ డెవలపర్‌లుగా, మనం పరీక్షలు రాయడానికి గణనీయమైన సమయాన్ని వెచ్చిస్తాం. మన అప్లికేషన్‌లు పటిష్టంగా, నమ్మదగినవిగా, మరియు రిగ్రెషన్‌లు లేకుండా ఉన్నాయని నిర్ధారించుకోవడానికి మనం యూనిట్ పరీక్షలు, ఇంటిగ్రేషన్ పరీక్షలు, మరియు ఎండ్-టు-ఎండ్ పరీక్షలను చాలా శ్రద్ధగా రూపొందిస్తాం. దీనికి ప్రధాన పద్ధతి ఉదాహరణ-ఆధారిత పరీక్ష (example-based testing). మనం ఒక నిర్దిష్ట ఇన్‌పుట్‌ను ఆలోచించి, ఒక నిర్దిష్ట అవుట్‌పుట్‌ను ధృవీకరిస్తాం. ఇన్‌పుట్ `[1, 2, 3]` అవుట్‌పుట్ `6`ను ఇవ్వాలి. ఇన్‌పుట్ `"hello"` `"HELLO"`గా మారాలి. కానీ ఈ విధానంలో ఒక నిశ్శబ్దమైన, దాగి ఉన్న బలహీనత ఉంది: మన స్వంత ఊహ.
మీరు ఖాళీ అర్రేతో పరీక్షించడం మర్చిపోతే? ఒక నెగటివ్ సంఖ్య? యూనికోడ్ అక్షరాలు ఉన్న స్ట్రింగ్? లోతుగా నెస్ట్ చేయబడిన ఆబ్జెక్ట్? మనం గమనించని ప్రతి ఎడ్జ్ కేస్ ఒక సంభావ్య బగ్. ఇక్కడే ప్రాపర్టీ-ఆధారిత పరీక్ష (PBT) రంగప్రవేశం చేస్తుంది, ఇది మనకు మరింత నమ్మకమైన మరియు స్థితిస్థాపకమైన సాఫ్ట్‌వేర్‌ను నిర్మించడంలో సహాయపడే ఒక శక్తివంతమైన పద్ధతి మార్పును అందిస్తుంది.
ఈ సమగ్ర మార్గదర్శి జావాస్క్రిప్ట్‌లో ప్రాపర్టీ-ఆధారిత పరీక్ష ప్రపంచంలోకి మిమ్మల్ని తీసుకెళ్తుంది. ఇది ఏమిటి, ఇది ఎందుకు అంత ప్రభావవంతంగా ఉంది, మరియు ప్రసిద్ధ లైబ్రరీ అయిన `fast-check` ఉపయోగించి మీ ప్రాజెక్ట్‌లలో ఈరోజే దాన్ని ఎలా అమలు చేయవచ్చో మనం అన్వేషిస్తాం.
సాంప్రదాయ ఉదాహరణ-ఆధారిత పరీక్ష యొక్క పరిమితులు
సంఖ్యల అర్రేను సార్ట్ చేసే ఒక సాధారణ ఫంక్షన్‌ను పరిశీలిద్దాం. జెస్ట్ లేదా వైటెస్ట్ వంటి ప్రసిద్ధ ఫ్రేమ్‌వర్క్‌ను ఉపయోగించి, మన పరీక్ష ఇలా ఉండవచ్చు:
// A simple (and slightly naive) sort function
function sortNumbers(arr) {
return [...arr].sort((a, b) => a - b);
}
// A typical example-based test
test('sortNumbers should correctly sort a simple array', () => {
const inputArray = [3, 1, 4, 1, 5, 9];
const expectedArray = [1, 1, 3, 4, 5, 9];
expect(sortNumbers(inputArray)).toEqual(expectedArray);
});
ఈ పరీక్ష పాస్ అవుతుంది. మనం మరికొన్ని `it` లేదా `test` బ్లాక్‌లను జోడించవచ్చు:
- ఇప్పటికే సార్ట్ చేయబడిన అర్రే.
- నెగటివ్ సంఖ్యలు ఉన్న అర్రే.
- సున్నా ఉన్న అర్రే.
- ఖాళీ అర్రే.
- డూప్లికేట్ సంఖ్యలు ఉన్న అర్రే (దీనిని మనం ఇప్పటికే కవర్ చేశాం).
మనకు బాగుందనిపిస్తుంది. మనం ప్రాథమిక అంశాలను కవర్ చేశాం. కానీ మనం ఏమి మిస్ అయ్యాం? `[-0, 0]` గురించి ఏమిటి? `[Infinity, -Infinity]` గురించి ఏమిటి? పనితీరు పరిమితులను లేదా విచిత్రమైన జావాస్క్రిప్ట్ ఇంజిన్ ఆప్టిమైజేషన్‌లను తాకగల చాలా పెద్ద అర్రే గురించి ఏమిటి? ఇక్కడ ప్రాథమిక సమస్య ఏమిటంటే మనం డేటాను మాన్యువల్‌గా ఎంచుకుంటున్నాం. మనం ఊహించగల ఉదాహరణల వలెనే మన పరీక్షలు కూడా బాగుంటాయి, మరియు డేటా యొక్క అన్ని విచిత్రమైన మరియు అద్భుతమైన నిర్మాణాలను ఊహించడంలో మానవులు ప్రసిద్ధంగా విఫలమవుతారు.
ఉదాహరణ-ఆధారిత పరీక్ష మీ కోడ్ కొన్ని చేతితో ఎంచుకున్న సందర్భాల కోసం పనిచేస్తుందని ధృవీకరిస్తుంది. ప్రాపర్టీ-ఆధారిత పరీక్ష మీ కోడ్ మొత్తం తరగతుల ఇన్‌పుట్‌ల కోసం పనిచేస్తుందని ధృవీకరిస్తుంది.
ప్రాపర్టీ-ఆధారిత పరీక్ష అంటే ఏమిటి? ఒక పద్ధతి మార్పు
ప్రాపర్టీ-ఆధారిత పరీక్ష స్క్రిప్ట్‌ను తిప్పివేస్తుంది. ఒక నిర్దిష్ట ఇన్‌పుట్ ఒక నిర్దిష్ట అవుట్‌పుట్‌ను ఇస్తుందని నిర్ధారించడానికి బదులుగా, మీరు మీ కోడ్ యొక్క సాధారణ ప్రాపర్టీని నిర్వచిస్తారు, అది ఏదైనా చెల్లుబాటు అయ్యే ఇన్‌పుట్‌కు నిజంగా ఉండాలి. ఆ తర్వాత టెస్టింగ్ ఫ్రేమ్‌వర్క్ మీ ప్రాపర్టీని తప్పు అని నిరూపించడానికి వందలు లేదా వేల యాదృచ్ఛిక ఇన్‌పుట్‌లను ఉత్పత్తి చేస్తుంది.
ఒక "ప్రాపర్టీ" అనేది ఒక ఇన్వేరియంట్—మీ ఫంక్షన్ ప్రవర్తన గురించి ఒక ఉన్నత-స్థాయి నియమం. మన `sortNumbers` ఫంక్షన్ కోసం, కొన్ని ప్రాపర్టీలు ఇలా ఉండవచ్చు:
- ఐడెంపోటెన్స్ (Idempotence): ఇప్పటికే సార్ట్ చేయబడిన అర్రేను మళ్ళీ సార్ట్ చేయడం వల్ల అది మారకూడదు. `sortNumbers(sortNumbers(arr))` అనేది `sortNumbers(arr)` మాదిరిగానే ఉండాలి.
- పొడవు మార్పులేకపోవడం (Length Invariance): సార్ట్ చేయబడిన అర్రే అసలు అర్రే వలె అదే పొడవును కలిగి ఉండాలి.
- కంటెంట్ మార్పులేకపోవడం (Content Invariance): సార్ట్ చేయబడిన అర్రే అసలు అర్రేలోని అవే ఎలిమెంట్లను కలిగి ఉండాలి, కేవలం వేరే క్రమంలో.
- ఆర్డర్ (Order): సార్ట్ చేయబడిన అర్రేలోని ఏవైనా రెండు ప్రక్క ప్రక్క ఎలిమెంట్ల కోసం, `sorted[i] <= sorted[i+1]` అవ్వాలి.
ఈ విధానం మిమ్మల్ని వ్యక్తిగత ఉదాహరణల గురించి ఆలోచించడం నుండి మీ కోడ్ యొక్క ప్రాథమిక కాంట్రాక్ట్ గురించి ఆలోచించేలా చేస్తుంది. ఈ ఆలోచనా విధానంలో మార్పు మెరుగైన, మరింత ఊహించదగిన APIలను రూపొందించడానికి చాలా విలువైనది.
PBT యొక్క ప్రధాన భాగాలు
ఒక ప్రాపర్టీ-ఆధారిత పరీక్ష ఫ్రేమ్‌వర్క్‌లో సాధారణంగా రెండు కీలక భాగాలు ఉంటాయి:
- జనరేటర్లు (లేదా ఆర్బిటరరీలు): ఇవి నిర్దిష్ట రకాల (పూర్ణాంకాలు, స్ట్రింగ్‌లు, ఆబ్జెక్ట్‌ల అర్రేలు, మొదలైనవి) ప్రకారం విస్తృత శ్రేణి యాదృచ్ఛిక డేటాను ఉత్పత్తి చేయడానికి బాధ్యత వహిస్తాయి. అవి కేవలం "హ్యాపీ పాత్" డేటాను మాత్రమే కాకుండా, ఖాళీ స్ట్రింగ్‌లు, `NaN`, `Infinity` వంటి క్లిష్టమైన ఎడ్జ్ కేసులను కూడా ఉత్పత్తి చేసేంత తెలివైనవి.
- ష్రింకింగ్ (Shrinking): ఇది మాయాజాలం. ఫ్రేమ్‌వర్క్ మీ ప్రాపర్టీని తప్పు అని నిరూపించే (అంటే, పరీక్ష విఫలమయ్యే) ఇన్‌పుట్‌ను కనుగొన్నప్పుడు, అది కేవలం ఆ పెద్ద, యాదృచ్ఛిక ఇన్‌పుట్‌ను రిపోర్ట్ చేయదు. బదులుగా, అది వైఫల్యానికి కారణమయ్యే అతి చిన్న మరియు సరళమైన ఇన్‌పుట్‌ను కనుగొనడానికి క్రమపద్ధతిలో ప్రయత్నిస్తుంది. ఇది డీబగ్గింగ్‌ను ఘాతాంకంగా సులభం చేస్తుంది.
ప్రారంభించడం: `fast-check`తో PBTని అమలు చేయడం
జావాస్క్రిప్ట్ ఎకోసిస్టమ్‌లో అనేక PBT లైబ్రరీలు ఉన్నప్పటికీ, `fast-check` ఒక పరిపక్వమైన, శక్తివంతమైన మరియు చక్కగా నిర్వహించబడే ఎంపిక. ఇది జెస్ట్, వైటెస్ట్, మోచా మరియు జాస్మిన్ వంటి ప్రసిద్ధ టెస్టింగ్ ఫ్రేమ్‌వర్క్‌లతో సజావుగా ఇంటిగ్రేట్ అవుతుంది.
ఇన్‌స్టాలేషన్ మరియు సెటప్
మొదట, మీ ప్రాజెక్ట్ యొక్క డెవలప్‌మెంట్ డిపెండెన్సీలకు `fast-check`ను జోడించండి. మీరు జెస్ట్ వంటి టెస్ట్ రన్నర్‌ను ఉపయోగిస్తున్నారని మేము భావిస్తున్నాము.
npm install --save-dev fast-check jest
# or
yarn add --dev fast-check jest
# or
pnpm add -D fast-check jest
మీ మొదటి ప్రాపర్టీ-ఆధారిత పరీక్ష
మన `sortNumbers` పరీక్షను `fast-check` ఉపయోగించి తిరిగి వ్రాద్దాం. మనం ఇంతకుముందు నిర్వచించిన "ఆర్డర్" ప్రాపర్టీని పరీక్షిస్తాం: ప్రతి ఎలిమెంట్ దాని తర్వాతి ఎలిమెంట్ కంటే తక్కువగా లేదా సమానంగా ఉండాలి.
import * as fc from 'fast-check';
// The same function from before
function sortNumbers(arr) {
return [...arr].sort((a, b) => a - b);
}
test('the output of sortNumbers should be a sorted array', () => {
// 1. Describe the property
fc.assert(
// 2. Define the arbitraries (input generators)
fc.property(fc.array(fc.integer()), (data) => {
// `data` is a randomly generated array of integers
const sorted = sortNumbers(data);
// 3. Define the predicate (the property to check)
for (let i = 0; i < sorted.length - 1; ++i) {
if (sorted[i] > sorted[i + 1]) {
return false; // The property is falsified
}
}
return true; // The property holds for this input
})
);
});
test('sorting should not change the array length', () => {
fc.assert(
fc.property(fc.array(fc.float()), (data) => {
const sorted = sortNumbers(data);
return sorted.length === data.length;
})
);
});
దీనిని విశ్లేషిద్దాం:
- `fc.assert()`: ఇది రన్నర్. ఇది మీ ప్రాపర్టీ చెక్‌ను చాలాసార్లు (డిఫాల్ట్‌గా 100) అమలు చేస్తుంది.
- `fc.property()`: ఇది ప్రాపర్టీని నిర్వచిస్తుంది. ఇది ఒకటి లేదా అంతకంటే ఎక్కువ ఆర్బిటరరీలను ఆర్గ్యుమెంట్‌లుగా తీసుకుంటుంది, ఆ తర్వాత ఒక ప్రెడికేట్ ఫంక్షన్ ఉంటుంది.
- `fc.array(fc.integer())`: ఇది మన ఆర్బిటరరీ. ఇది `fast-check`కు పూర్ణాంకాల (`fc.integer()`) అర్రే (`fc.array`)ను ఉత్పత్తి చేయమని చెబుతుంది. `fast-check` స్వయంచాలకంగా వివిధ పొడవులు, వివిధ పూర్ణాంక విలువల (ధనాత్మక, రుణాత్మక, సున్నా, మొదలైనవి) తో అర్రేలను ఉత్పత్తి చేస్తుంది.
- ప్రెడికేట్ (The Predicate): అనామక ఫంక్షన్ `(data) => { ... }` లో మన లాజిక్ ఉంటుంది. ఇది యాదృచ్ఛికంగా ఉత్పత్తి చేయబడిన డేటాను అందుకుంటుంది మరియు ప్రాపర్టీ నిలబడితే `true` లేదా ఉల్లంఘిస్తే `false` ను తిరిగి ఇవ్వాలి. `fast-check` వైఫల్యంపై ఎర్రర్ త్రో చేసే ప్రెడికేట్ ఫంక్షన్‌లకు కూడా మద్దతు ఇస్తుంది, ఇది జెస్ట్ యొక్క `expect` అసర్షన్‌లతో చక్కగా ఇంటిగ్రేట్ అవుతుంది.
ఇప్పుడు, ఒక చేతితో ఎంచుకున్న అర్రేతో ఒకే పరీక్షకు బదులుగా, మన సూట్‌ను రన్ చేసిన ప్రతిసారీ మన సార్టింగ్ లాజిక్‌ను 100 విభిన్న, స్వయంచాలకంగా ఉత్పత్తి చేయబడిన అర్రేలతో ధృవీకరించే పరీక్ష మనకు ఉంది. మనం కేవలం కొన్ని లైన్ల కోడ్‌తో మన టెస్ట్ కవరేజ్‌ను భారీగా పెంచాము.
ఆర్బిటరరీలను అన్వేషించడం: సరైన డేటాను ఉత్పత్తి చేయడం
PBT యొక్క శక్తి విభిన్నమైన మరియు సవాలుతో కూడిన డేటాను ఉత్పత్తి చేసే దాని సామర్థ్యంలో ఉంది. మీరు ఊహించగల దాదాపు ఏ డేటా నిర్మాణాన్ని కవర్ చేయడానికి `fast-check` ఒక గొప్ప ఆర్బిటరరీల సమితిని అందిస్తుంది.
ప్రాథమిక ఆర్బిటరరీలు
ఇవి మీ డేటా జనరేషన్ కోసం బిల్డింగ్ బ్లాక్‌లు.
- `fc.integer()`, `fc.float()`, `fc.bigInt()`: సంఖ్యల కోసం. వాటిని పరిమితం చేయవచ్చు, ఉదా., `fc.integer({ min: 0, max: 100 })`.
- `fc.string()`, `fc.asciiString()`, `fc.unicodeString()`: వివిధ అక్షర సమితుల స్ట్రింగ్‌ల కోసం.
- `fc.boolean()`: `true` లేదా `false` కోసం.
- `fc.constant(value)`: ఎల్లప్పుడూ అదే విలువను తిరిగి ఇస్తుంది. `fc.oneof`తో కలపడానికి ఉపయోగపడుతుంది.
- `fc.constantFrom(val1, val2, ...)`: అందించిన స్థిరమైన విలువలలో ఒకదాన్ని తిరిగి ఇస్తుంది.
సంక్లిష్టమైన మరియు మిశ్రమ ఆర్బిటరరీలు
సంక్లిష్ట డేటా నిర్మాణాలను సృష్టించడానికి మీరు ప్రాథమిక ఆర్బిటరరీలను కలపవచ్చు.
- `fc.array(arbitrary, constraints)`: అందించిన ఆర్బిటరరీ ద్వారా సృష్టించబడిన ఎలిమెంట్ల అర్రేను ఉత్పత్తి చేస్తుంది. మీరు `minLength` మరియు `maxLength`ను పరిమితం చేయవచ్చు.
- `fc.tuple(arb1, arb2, ...)`: ప్రతి ఎలిమెంట్ ఒక నిర్దిష్ట, విభిన్న రకాన్ని కలిగి ఉండే ఒక స్థిర-పొడవు అర్రేను ఉత్పత్తి చేస్తుంది.
- `fc.object(shape)`: నిర్వచించిన నిర్మాణంతో ఆబ్జెక్ట్‌లను ఉత్పత్తి చేస్తుంది. ఉదాహరణ: `fc.object({ id: fc.uuidV(4), name: fc.string() })`.
- `fc.oneof(arb1, arb2, ...)`: అందించిన ఆర్బిటరరీలలో ఏదైనా ఒక దాని నుండి ఒక విలువను ఉత్పత్తి చేస్తుంది. బహుళ డేటా రకాలను (ఉదా., `string | number`) నిర్వహించే ఫంక్షన్‌లను పరీక్షించడానికి ఇది అద్భుతమైనది.
- `fc.record({ key: arb, value: arb })`: డిక్షనరీలు లేదా మ్యాప్‌లుగా ఉపయోగించడానికి ఆబ్జెక్ట్‌లను ఉత్పత్తి చేస్తుంది, ఇక్కడ కీలు మరియు విలువలు ఆర్బిటరరీల నుండి ఉత్పత్తి చేయబడతాయి.
`map` మరియు `chain` తో కస్టమ్ ఆర్బిటరరీలను సృష్టించడం
కొన్నిసార్లు మీకు ప్రామాణిక ఆకారానికి సరిపోని డేటా అవసరం. `fast-check` ఇప్పటికే ఉన్న వాటిని మార్చడం ద్వారా మీ స్వంత ఆర్బిటరరీలను సృష్టించడానికి మిమ్మల్ని అనుమతిస్తుంది.
`.map()` ఉపయోగించడం
`.map()` పద్ధతి ఒక ఆర్బిటరరీ యొక్క అవుట్‌పుట్‌ను వేరొకదానికి మారుస్తుంది. ఉదాహరణకు, ఖాళీగా లేని స్ట్రింగ్‌లను ఉత్పత్తి చేసే ఆర్బిటరరీని సృష్టిద్దాం.
const nonEmptyStringArb = fc.string({ minLength: 1 });
// Or, by transforming an array of characters
const nonAStringArb = fc.array(fc.char().filter(c => c !== 'a'))
.map(chars => chars.join(''));
`.chain()` ఉపయోగించడం
`.chain()` పద్ధతి మరింత శక్తివంతమైనది. ఇది మునుపటి దాని ఉత్పత్తి చేయబడిన విలువ ఆధారంగా కొత్త ఆర్బిటరరీని సృష్టించడానికి మిమ్మల్ని అనుమతిస్తుంది. పరస్పర సంబంధం ఉన్న డేటాను సృష్టించడానికి ఇది అవసరం.
మీరు ఒక అర్రేను మరియు ఆ అర్రే కోసం ఒక చెల్లుబాటు అయ్యే ఇండెక్స్‌ను ఉత్పత్తి చేయవలసి ఉందని ఊహించుకోండి. మీరు దీన్ని రెండు వేర్వేరు ఆర్బిటరరీలతో చేయలేరు, ఎందుకంటే ఇండెక్స్ పరిధికి వెలుపల ఉండవచ్చు. `.chain()` దీన్ని సంపూర్ణంగా పరిష్కరిస్తుంది.
// Generate an array and a valid index into it
const arrayAndValidIndexArb = fc.array(fc.anything()).chain(arr => {
// Based on the generated array `arr`, create a new arbitrary for the index
const indexArb = fc.integer({ min: 0, max: arr.length - 1 });
// Return a tuple of the array and the generated index
return fc.tuple(fc.constant(arr), indexArb);
});
// Usage in a test
test('slicing at a valid index should work', () => {
fc.assert(
fc.property(arrayAndValidIndexArb, ([arr, index]) => {
// Both `arr` and `index` are guaranteed to be compatible
const sliced = arr.slice(0, index);
expect(sliced.length).toBe(index);
})
);
});
ష్రింకింగ్ యొక్క శక్తి: డీబగ్గింగ్ సులభం చేయబడింది
ప్రాపర్టీ-ఆధారిత పరీక్ష యొక్క అత్యంత ఆకర్షణీయమైన ఫీచర్ ష్రింకింగ్. దాన్ని ఆచరణలో చూడటానికి, ఉద్దేశపూర్వకంగా ఒక బగ్గీ ఫంక్షన్‌ను సృష్టిద్దాం.
// This function fails if the input array contains the number 42
function sumWithoutBug(arr) {
if (arr.includes(42)) {
throw new Error('This number is not allowed!');
}
return arr.reduce((acc, val) => acc + val, 0);
}
test('sumWithoutBug should sum numbers', () => {
fc.assert(
fc.property(fc.array(fc.integer()), (data) => {
sumWithoutBug(data);
})
);
});
మీరు ఈ పరీక్షను రన్ చేసినప్పుడు, `fast-check` ఖచ్చితంగా ఒక విఫలమైన కేసును కనుగొంటుంది. కానీ అది కనుగొన్న మొదటి యాదృచ్ఛిక అర్రేను రిపోర్ట్ చేయదు, అది `[-1024, 500, 42, 987, -2000]` వంటిది కావచ్చు. అటువంటి వైఫల్య నివేదిక అంత సహాయకరంగా ఉండదు. సమస్యాత్మకమైన `42`ను కనుగొనడానికి మీరు దాన్ని మాన్యువల్‌గా తనిఖీ చేయాల్సి ఉంటుంది.
బదులుగా, `fast-check` యొక్క ష్రింకర్ పని చేయడం ప్రారంభిస్తుంది. ఇది వైఫల్యాన్ని చూసి ఇన్‌పుట్‌ను సరళీకరించడం ప్రారంభిస్తుంది:
- నేను ఒక ఎలిమెంట్‌ను తీసివేయగలనా? `[500, 42, 987, -2000]` ప్రయత్నించండి. ఇంకా విఫలమవుతోంది. మంచిది.
- నేను మరొకదాన్ని తీసివేయగలనా? `[42, 987, -2000]` ప్రయత్నించండి. ఇంకా విఫలమవుతోంది.
- ...మరియు అలా, పరీక్ష పాస్ అయ్యే వరకు మరిన్ని ఎలిమెంట్లను తీసివేయలేనంత వరకు.
- ఇది సంఖ్యలను చిన్నవిగా చేయడానికి కూడా ప్రయత్నిస్తుంది. `42`ని `0` చేయవచ్చా? లేదు, పరీక్ష పాస్ అవుతుంది. `41` చేయవచ్చా? పరీక్ష పాస్ అవుతుంది. ఇది దానిని కుదిస్తుంది.
తుది ఎర్రర్ రిపోర్ట్ ఇలా ఉంటుంది:
Error: Property failed after 15 tests
{ seed: 12345678, path: "14", endOnFailure: true }
Counterexample: [[42]]
Shrunk 5 time(s)
Got error: This number is not allowed!
ఇది వైఫల్యానికి కారణమైన ఖచ్చితమైన, కనీస ఇన్‌పుట్‌ను మీకు చెబుతుంది: కేవలం `[42]` సంఖ్యను కలిగి ఉన్న అర్రే. ఇది వెంటనే బగ్ యొక్క మూలాన్ని సూచిస్తుంది, డీబగ్గింగ్‌లో మీకు అపారమైన సమయం మరియు శ్రమను ఆదా చేస్తుంది.
ప్రాక్టికల్ PBT వ్యూహాలు మరియు వాస్తవ-ప్రపంచ ఉదాహరణలు
PBT కేవలం గణిత ఫంక్షన్‌ల కోసం మాత్రమే కాదు. ఇది సాఫ్ట్‌వేర్ డెవలప్‌మెంట్ యొక్క అనేక రంగాలకు వర్తించే ఒక బహుముఖ సాధనం.
ప్రాపర్టీ: విలోమ ఫంక్షన్‌లు (Inverse Functions)
మీకు డేటాను ఎన్‌కోడ్ చేసే ఫంక్షన్ మరియు దాన్ని డీకోడ్ చేసే మరొక ఫంక్షన్ ఉంటే, అవి ఒకదానికొకటి విలోమాలు. ఎన్‌కోడ్ చేయబడిన విలువను డీకోడ్ చేయడం ఎల్లప్పుడూ అసలు విలువను తిరిగి ఇవ్వాలనేది పరీక్షించడానికి ఒక గొప్ప ప్రాపర్టీ.
// `encode` and `decode` could be for base64, URI components, or custom serialization
function encode(obj) { return JSON.stringify(obj); }
function decode(str) { return JSON.parse(str); }
test('decode(encode(x)) should be equal to x', () => {
// `fc.jsonValue()` generates any valid JSON value: strings, numbers, objects, arrays
fc.assert(
fc.property(fc.jsonValue(), (originalValue) => {
const encoded = encode(originalValue);
const decoded = decode(encoded);
expect(decoded).toEqual(originalValue);
})
);
});
ప్రాపర్టీ: ఐడెంపోటెన్స్ (Idempotence)
ఒక ఆపరేషన్‌ను చాలాసార్లు వర్తింపజేయడం ఒకసారి వర్తింపజేసినట్లే అదే ప్రభావాన్ని కలిగి ఉంటే అది ఐడెంపోటెంట్. `f(f(x)) === f(x)`. డేటా క్లీనింగ్ ఫంక్షన్‌లు లేదా REST APIలోని `DELETE` ఎండ్‌పాయింట్‌ల వంటి వాటికి ఇది ఒక కీలకమైన ప్రాపర్టీ.
// A function that removes leading/trailing whitespace and collapses multiple spaces
function normalizeWhitespace(text) {
return text.trim().replace(/\s+/g, ' ');
}
test('normalizeWhitespace should be idempotent', () => {
fc.assert(
fc.property(fc.string(), (originalString) => {
const once = normalizeWhitespace(originalString);
const twice = normalizeWhitespace(once);
expect(twice).toBe(once);
})
);
});
ప్రాపర్టీ: స్టేట్‌ఫుల్ (మోడల్-ఆధారిత) టెస్టింగ్
ఇది మరింత అధునాతనమైనది కానీ UI కాంపోనెంట్, షాపింగ్ కార్ట్ లేదా స్టేట్ మెషీన్ వంటి అంతర్గత స్థితితో ఉన్న సిస్టమ్‌లను పరీక్షించడానికి అద్భుతంగా శక్తివంతమైన టెక్నిక్. మీ సిస్టమ్ యొక్క ఒక సాధారణ సాఫ్ట్‌వేర్ మోడల్‌ను మరియు మీ మోడల్ మరియు వాస్తవ అమలు రెండింటిపై అమలు చేయగల కమాండ్‌ల శ్రేణిని సృష్టించడం దీని ఆలోచన. మోడల్ యొక్క స్థితి మరియు వాస్తవ సిస్టమ్ యొక్క స్థితి ఎల్లప్పుడూ సరిపోలాలనేది ప్రాపర్టీ.
`fast-check` దీని కోసం `fc.commands`ను అందిస్తుంది. ఒక సాధారణ కౌంటర్‌ను మోడల్ చేద్దాం:
// The real implementation
class Counter {
constructor() { this.count = 0; }
increment() { this.count++; }
decrement() { this.count--; }
get() { return this.count; }
}
// The commands for fast-check
const incrementCmd = fc.command(
// check: a function to check if the command can be run on the model
(model) => true,
// run: a function to execute the command on both model and real system
(model, real) => {
model.count++;
real.increment();
expect(real.get()).toBe(model.count);
}
);
const decrementCmd = fc.command(
(model) => true,
(model, real) => {
model.count--;
real.decrement();
expect(real.get()).toBe(model.count);
}
);
test('Counter should behave according to the model', () => {
fc.assert(
fc.property(fc.commands([incrementCmd, decrementCmd]), (cmds) => {
const model = { count: 0 };
const real = new Counter();
fc.modelRun(() => ({ model, real }), cmds);
})
);
});
ఈ పరీక్షలో, `fast-check` `increment` మరియు `decrement` కమాండ్‌ల యొక్క యాదృచ్ఛిక క్రమాన్ని ఉత్పత్తి చేస్తుంది, వాటిని మన సాధారణ ఆబ్జెక్ట్ మోడల్ మరియు వాస్తవ `Counter` క్లాస్ రెండింటిపై అమలు చేస్తుంది మరియు అవి ఎప్పుడూ విడిపోకుండా చూసుకుంటుంది. ఇది ఉదాహరణ-ఆధారిత పరీక్షతో కనుగొనడం దాదాపు అసాధ్యమైన సంక్లిష్టమైన స్టేట్‌ఫుల్ లాజిక్‌లోని సూక్ష్మ బగ్స్‌ను బహిర్గతం చేయగలదు.
ప్రాపర్టీ-ఆధారిత పరీక్షను ఎప్పుడు ఉపయోగించకూడదు
PBT మీ టెస్టింగ్ టూల్‌కిట్‌కు ఒక శక్తివంతమైన చేరిక, కానీ ఇది అన్ని ఇతర రకాల పరీక్షలకు ప్రత్యామ్నాయం కాదు. ఇది వెండి బుల్లెట్ కాదు.
ఉదాహరణ-ఆధారిత పరీక్ష ఈ సందర్భాలలో తరచుగా మెరుగ్గా ఉంటుంది:
- నిర్దిష్ట, తెలిసిన వ్యాపార నియమాలను పరీక్షించడం. ఒక పన్ను గణన ఒక నిర్దిష్ట ఇన్‌పుట్‌కు ఖచ్చితంగా `$10.53` ఉత్పత్తి చేయాలంటే, ఒక సాధారణ ఉదాహరణ-ఆధారిత పరీక్ష స్పష్టంగా మరియు మరింత ప్రత్యక్షంగా ఉంటుంది. ఇది తెలిసిన అవసరం కోసం ఒక రిగ్రెషన్ పరీక్ష.
- "ప్రాపర్టీ" కేవలం "ఇన్‌పుట్ X అవుట్‌పుట్ Yను ఉత్పత్తి చేస్తుంది" అయినప్పుడు. ఫంక్షన్ యొక్క ప్రవర్తన గురించి ఉన్నత-స్థాయి, సాధారణీకరించగల నియమం లేకపోతే, ప్రాపర్టీ-ఆధారిత పరీక్షను బలవంతం చేయడం దాని విలువ కంటే ఎక్కువ సంక్లిష్టంగా ఉంటుంది.
- విజువల్ కరెక్ట్‌నెస్ కోసం యూజర్ ఇంటర్‌ఫేస్‌లను పరీక్షించడం. మీరు PBTతో UI కాంపోనెంట్ యొక్క స్టేట్ లాజిక్‌ను పరీక్షించగలిగినప్పటికీ, ఒక నిర్దిష్ట విజువల్ లేఅవుట్ లేదా శైలిని తనిఖీ చేయడం స్నాప్‌షాట్ టెస్టింగ్ లేదా విజువల్ రిగ్రెషన్ టూల్స్ ద్వారా ఉత్తమంగా నిర్వహించబడుతుంది.
అత్యంత ప్రభావవంతమైన వ్యూహం ఒక హైబ్రిడ్ విధానం (hybrid approach). మీ అల్గారిథమ్‌లు, డేటా ట్రాన్స్‌ఫర్మేషన్‌లు మరియు స్టేట్‌ఫుల్ లాజిక్‌ను అనంతమైన అవకాశాలకు వ్యతిరేకంగా ఒత్తిడి-పరీక్షించడానికి ప్రాపర్టీ-ఆధారిత పరీక్షలను ఉపయోగించండి. నిర్దిష్ట, క్లిష్టమైన వ్యాపార అవసరాలను నిర్ధారించడానికి మరియు తెలిసిన బగ్స్‌పై రిగ్రెషన్‌లను నివారించడానికి సాంప్రదాయ ఉదాహరణ-ఆధారిత పరీక్షలను ఉపయోగించండి.
ముగింపు: కేవలం ఉదాహరణలలో కాకుండా, ప్రాపర్టీలలో ఆలోచించండి
ప్రాపర్టీ-ఆధారిత పరీక్ష మనం కరెక్ట్‌నెస్ గురించి ఎలా ఆలోచిస్తామో దానిలో ఒక లోతైన మార్పును ప్రోత్సహిస్తుంది. ఇది మనల్ని వ్యక్తిగత ఉదాహరణల నుండి వెనక్కి తగ్గి, మన కోడ్ పాటించాల్సిన ప్రాథమిక సూత్రాలు మరియు కాంట్రాక్ట్‌లను పరిగణలోకి తీసుకునేలా చేస్తుంది. అలా చేయడం ద్వారా, మనం:
- మనం పరీక్షలు రాయాలని ఎప్పుడూ ఆలోచించని ఆశ్చర్యకరమైన ఎడ్జ్ కేసులను కనుగొనవచ్చు.
- మన కోడ్ యొక్క పటిష్టతపై చాలా ఎక్కువ నమ్మకాన్ని పొందవచ్చు.
- కేవలం కొన్ని ఇన్‌పుట్‌లపై దాని అవుట్‌పుట్‌ను కాకుండా మన సిస్టమ్ యొక్క ప్రవర్తనను డాక్యుమెంట్ చేసే మరింత వ్యక్తీకరణాత్మక పరీక్షలను వ్రాయవచ్చు.
- ష్రింకింగ్ శక్తికి ధన్యవాదాలు, డీబగ్ సమయాన్ని గణనీయంగా తగ్గించవచ్చు.
ప్రాపర్టీ-ఆధారిత పరీక్షను స్వీకరించడం మొదట అపరిచితంగా అనిపించవచ్చు, కానీ ఈ పెట్టుబడికి తగిన ప్రతిఫలం ఉంటుంది. చిన్నగా ప్రారంభించండి. మీ కోడ్‌బేస్‌లో ఒక స్వచ్ఛమైన ఫంక్షన్‌ను ఎంచుకోండి—డేటా ట్రాన్స్‌ఫర్మేషన్ లేదా సంక్లిష్ట గణనను నిర్వహించేది—మరియు దాని కోసం ఒక ప్రాపర్టీని నిర్వచించడానికి ప్రయత్నించండి. మీ తదుపరి ప్రాజెక్ట్‌కు ఒక ప్రాపర్టీ-ఆధారిత పరీక్షను జోడించండి. అది దాని మొదటి ముఖ్యమైన బగ్‌ను కనుగొనడాన్ని మీరు చూసినప్పుడు, ప్రపంచ ప్రేక్షకుల కోసం మెరుగైన, మరింత నమ్మదగిన సాఫ్ట్‌వేర్‌ను నిర్మించడంలో దాని శక్తి గురించి మీకు నమ్మకం కలుగుతుంది.
మరిన్ని వనరులు
- ఫాస్ట్-చెక్ అధికారిక డాక్యుమెంటేషన్
- ప్రాపర్టీ-ఆధారిత పరీక్షను అర్థం చేసుకోవడం స్కాట్ వ్లాషిన్ ద్వారా (ఒక క్లాసిక్, భాష-అజ్ఞాత పరిచయం)